package com.moon.app;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.provider.MediaStore;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageContainer;
import com.android.volley.toolbox.ImageLoader.ImageListener;
import com.android.volley.toolbox.Volley;
import com.moon.R;
import com.moon.common.AbstractActivity;
import com.moon.constants.MoonConstants;
import com.moon.model.UserJsonResult;
import com.moon.utils.BitmapImageCache;
import com.moon.utils.HttpClientUtils;
import com.moon.utils.ImageLoadUtils;
import com.moon.utils.JacksonUtils;
import com.moon.utils.SharedPreferencesUtils;
import com.moon.utils.UserUtils;

/**
 * 用户设置
 * 
 * @author paul
 * @date 2014年5月10日
 */
public class UserSettingActivity extends AbstractActivity {
    private static final String TAG = UserSettingActivity.class.getSimpleName();

    TextView                    email;
    ImageView                   headImage;
    TextView                    name;
    TextView                    introduce;
    String                      userId;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.user_setting);

        email = (TextView) findViewById(R.id.email);
        headImage = (ImageView) findViewById(R.id.headImage);
        name = (TextView) findViewById(R.id.name);
        introduce = (TextView) findViewById(R.id.introduce);

        initView();

        LinearLayout ll = (LinearLayout) findViewById(R.id.headLinear);
        ll.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                ShowPickDialog();
            }
        });

    }

    /**
     * 
     */
    private void initView() {
        SharedPreferences shareDate = getSharedPreferences(MoonConstants.SHARED_PREFERENCES_KEY,
                Context.MODE_PRIVATE);
        email.setText(shareDate.getString(MoonConstants.USER_EMAIL, null));
        name.setText(shareDate.getString(MoonConstants.USER_NAME, null));
        introduce.setText(shareDate.getString(MoonConstants.USER_INTRODUCE, null));
        userId = shareDate.getString(MoonConstants.USER_USER_ID, null);
        //两种加载图片的方式
        //new BitMapTask().execute(shareDate.getString(MoonConstants.USER_HEAD_IMGURL, null));
        loadImageByVolley(shareDate.getString(MoonConstants.USER_HEAD_IMGURL, null));
    }

    /**
     * 选择提示对话框
     */
    private void ShowPickDialog() {
        new AlertDialog.Builder(this).setTitle("设置头像...")
                .setNegativeButton("相册", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                        /**
                         * 刚开始，我自己也不知道ACTION_PICK是干嘛的，后来直接看Intent源码，
                         * 可以发现里面很多东西，Intent是个很强大的东西，大家一定仔细阅读下
                         */
                        Intent intent = new Intent(Intent.ACTION_PICK, null);

                        /**
                         * 下面这句话，与其它方式写是一样的效果，如果：
                         * intent.setData(MediaStore.Images
                         * .Media.EXTERNAL_CONTENT_URI);
                         * intent.setType(""image/*");设置数据类型
                         * 如果朋友们要限制上传到服务器的图片类型时可以直接写如
                         * ："image/jpeg 、 image/png等的类型"
                         * 这个地方小马有个疑问，希望高手解答下：就是这个数据URI与类型为什么要分两种形式来写呀？有什么区别？
                         */
                        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                                "image/*");
                        startActivityForResult(intent, 1);

                    }
                }).setPositiveButton("拍照", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                        dialog.dismiss();
                        /**
                         * 下面这句还是老样子，调用快速拍照功能，至于为什么叫快速拍照，大家可以参考如下官方
                         * 文档，you_sdk_path/docs/guide/topics/media/camera.html
                         * 我刚看的时候因为太长就认真看，其实是错的，这个里面有用的太多了，所以大家不要认为
                         * 官方文档太长了就不看了，其实是错的，这个地方小马也错了，必须改正
                         */
                        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                        //下面这句指定调用相机拍照后的照片存储的路径
                        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(Environment
                                .getExternalStorageDirectory(), "moon_temp.jpg")));
                        startActivityForResult(intent, 2);
                    }
                }).show();
    }

    //从本activity可以通过intent启动其它activity.  而从它们返回时,就会进此方法
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        //从其它view返回过来时,很可能 Intent data为空. 此时不做任何处理就可以了
        if (data == null) {
            return;
        }
        switch (requestCode) {
        // 如果是直接从相册获取
            case 1:
                startPhotoZoom(data.getData());
                break;
            // 如果是调用相机拍照时
            case 2:
                File temp = new File(Environment.getExternalStorageDirectory() + "/moon_temp.jpg");
                startPhotoZoom(Uri.fromFile(temp));
                break;
            // 取得裁剪后的图片
            case 3:
                /**
                 * 非空判断大家一定要验证，如果不验证的话， 在剪裁之后如果发现不满意，要重新裁剪，丢弃
                 * 当前功能时，会报NullException，小马只 在这个地方加下，大家可以根据不同情况在合适的 地方做判断处理类似情况
                 */
                setPicToView(data);
                break;
            default:
                break;

        }
        super.onActivityResult(requestCode, resultCode, data);
    }

    /**
     * 裁剪图片方法实现
     * 
     * @param uri
     */
    public void startPhotoZoom(Uri uri) {
        /*
         * 至于下面这个Intent的ACTION是怎么知道的，大家可以看下自己路径下的如下网页
         * yourself_sdk_path/docs/reference/android/content/Intent.html
         * 直接在里面Ctrl+F搜：CROP ，之前小马没仔细看过，其实安卓系统早已经有自带图片裁剪功能, 是直接调本地库的，小马不懂C C++
         * 这个不做详细了解去了，有轮子就用轮子，不再研究轮子是怎么 制做的了...吼吼
         */
        Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setDataAndType(uri, "image/*");
        //下面这个crop=true是设置在开启的Intent中设置显示的VIEW可裁剪
        intent.putExtra("crop", "true");
        // aspectX aspectY 是宽高的比例
        intent.putExtra("aspectX", 1);
        intent.putExtra("aspectY", 1);
        // outputX outputY 是裁剪图片宽高
        intent.putExtra("outputX", 100);
        intent.putExtra("outputY", 100);
        intent.putExtra("return-data", true);
        startActivityForResult(intent, 3);
    }

    /**
     * 保存裁剪之后的图片数据
     * 
     * @param picdata
     */
    private void setPicToView(Intent picdata) {
        Bundle extras = picdata.getExtras();
        if (extras != null) {
            Bitmap photo = extras.getParcelable("data");
            //压缩后  为什么到服务器上还是那么大?
            //photo = ImageCompressUtils.compressImage(photo,Bitmap.CompressFormat.JPEG,10);
//            String headImage = MediaStore.Images.Media.insertImage(getContentResolver(), photo,
//                    "headtemp", "headtemp");
            
            new UserSettingTask().execute(userId, name.getText().toString(), null, ImageLoadUtils.saveBitmap(photo,userId),email.getText().toString());
            //Drawable drawable = new BitmapDrawable(photo);
            //new UserSettingTask().execute(params);
            /**
             * 下面注释的方法是将裁剪之后的图片以Base64Coder的字符方式上 传到服务器，QQ头像上传采用的方法跟这个类似
             */

            /*
             * ByteArrayOutputStream stream = new ByteArrayOutputStream();
             * photo.compress(Bitmap.CompressFormat.JPEG, 60, stream); byte[] b
             * = stream.toByteArray(); // 将图片流以字符串形式存储下来 tp = new
             * String(Base64Coder.encodeLines(b));
             * 这个地方大家可以写下给服务器上传图片的实现，直接把tp直接上传就可以了， 服务器处理的方法是服务器那边的事了，吼吼
             * 如果下载到的服务器的数据还是以Base64Coder的形式的话，可以用以下方式转换 为我们可以用的图片类型就OK啦...吼吼
             * Bitmap dBitmap = BitmapFactory.decodeFile(tp); Drawable drawable
             * = new BitmapDrawable(dBitmap);
             */
            //ib.setBackgroundDrawable(drawable);
            // iv.setBackgroundDrawable(drawable);
        }
    }

//    /** 保存方法 */
//    private String saveBitmap(Bitmap bm) {
//        File filePath = new File("/sdcard/namecard/");
//        if (!filePath.exists()) {
//            filePath.mkdirs();
//        }
//        
//        File f = new File("/sdcard/namecard/", userId+".jpeg");
//        if (f.exists()) {
//            f.delete();
//        }
//
//        try {
//            FileOutputStream out = new FileOutputStream(f);
//            bm.compress(Bitmap.CompressFormat.JPEG, 100, out);
//            out.flush();
//            out.close();
//            return f.getPath();
//        } catch (Exception e) {
//            Log.e(TAG, "saveBitmap error,", e);
//            return null;
//        }
//    }

    //异步获取头像 -- AsyncTask方式
    private class BitMapTask extends AsyncTask<String, String, Bitmap> {
        @Override
        protected Bitmap doInBackground(String... params) {
            String url = MoonConstants.MOON_DOMAIN_STATIC_HEAD+params[0];
            return ImageLoadUtils.getBitmapFromUrl(url);
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            //图片加载
            if (bitmap != null) {
                headImage.setImageBitmap(bitmap);

            } else {
                //默认图加载
                headImage.setImageResource(R.drawable.app_panel_pic_icon);
            }
        }
    }

    /**
     * 利用Volley异步加载图片 注意方法参数: getImageListener(ImageView view, int
     * defaultImageResId, int errorImageResId) 第一个参数:显示图片的ImageView
     * 第二个参数:默认显示的图片资源 第三个参数:加载错误时显示的图片资源
     */
    private void loadImageByVolley(String imageUrl) {
        if (StringUtils.isBlank(imageUrl)) {
            //imageUrl="http://avatar.csdn.net/6/6/D/1_lfdfhl.jpg";  
            headImage.setImageResource(R.drawable.app_panel_pic_icon);
            return;
        }

        //String imageUrl="http://avatar.csdn.net/6/6/D/1_lfdfhl.jpg";  
        RequestQueue requestQueue = Volley.newRequestQueue(this);

//        //像循环处理一批ImageView是需要imageCache 的   这里只有一次  意义不大
//                final LruCache<String, Bitmap> lruCache = new LruCache<String, Bitmap>(20);  
//                ImageCache imageCache = new ImageCache() {  
//                    @Override  
//                    public void putBitmap(String key, Bitmap value) {  
//                        lruCache.put(key, value);  
//                    }  
//          
//                    @Override  
//                    public Bitmap getBitmap(String key) {  
//                        return lruCache.get(key);  
//                    }  
//                };  
        
        //真实Headurl
        String url = MoonConstants.MOON_DOMAIN_STATIC_HEAD+imageUrl;
        //删除缓存图片
        BitmapImageCache cache =(BitmapImageCache)BitmapImageCache.getInstance();
        //Bitmap bitmap = cache.getLruCache().get(getCacheKey(url,0,0));
        cache.getLruCache().remove(getCacheKey(url,0,0));
        //bitmap = cache.getLruCache().get(getCacheKey(url,0,0));
        
        //重新加载
        ImageLoader imageLoader = new ImageLoader(requestQueue, BitmapImageCache.getInstance());
        ImageListener listener = ImageLoader.getImageListener(headImage,
                R.drawable.app_panel_pic_icon, R.drawable.app_panel_pic_icon);
        ImageContainer headImage = imageLoader.get(url, listener);
        UserUtils.setHeadImage(null);
    }

    
    //@link ImageLoader.getCacheKey  它并不是以url为key  ,重新组装过
    private static String getCacheKey(String url, int maxWidth, int maxHeight) {
        return new StringBuilder(url.length() + 12).append("#W").append(maxWidth)
                .append("#H").append(maxHeight).append(url).toString();
    }
    
//    @Override
//    public boolean onKeyDown(int keyCode, KeyEvent event) {
//        // 退出提示
//        if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
//            startActivity(new Intent(this, MainActivity.class));
//            return true;
//        }
//        return super.onKeyDown(keyCode, event);
//    }
    
    private class UserSettingTask extends AsyncTask<String, String, Boolean> {
        String requestUrl = "/mobile_setting/modify_user.do";

        @Override
        protected Boolean doInBackground(String... params) {
            try {
                //请求服务器
                List<NameValuePair> pairs = convertParams(params);
                String json = HttpClientUtils.postWithImage(MoonConstants.MOON_DOMAIN + requestUrl,
                        pairs);
                UserJsonResult result = JacksonUtils.fromJSON(json, UserJsonResult.class);
                if (result.isSuccess()) {
                    //写用户共享数据
                    writeSharedData(result);
                  //initView();
                    return true;
                } else {
                    if (StringUtils.isNotBlank(result.getMessage())) {
                        publishProgress(result.getMessage());
                    }
                    return false;
                }
            } catch (Exception e) {
                // 提示用户网络异常
                String message = getString(R.string.network_error);
                Log.e(TAG, message, e);
                publishProgress(message);
                return false;
            }
        }

        @Override
        protected void onProgressUpdate(String... values) {
            Toast.makeText(getApplicationContext(), values[0], Toast.LENGTH_SHORT).show();
        }
        
        //要更新UI,必须重写此方法,不能在doInBackground直接操作UI
        @Override
        protected void onPostExecute(Boolean result) {
            initView();
        }
        /**
         * 组装request参数
         * 
         * @param params
         * @return
         */
        private List<NameValuePair> convertParams(String... params) {
            List<NameValuePair> pairs = new ArrayList<NameValuePair>();
            pairs.add(new BasicNameValuePair(MoonConstants.USER_USER_ID, params[0]));
            pairs.add(new BasicNameValuePair(MoonConstants.USER_NAME, params[1]));
            pairs.add(new BasicNameValuePair(MoonConstants.USER_INTRODUCE, params[2]));
            pairs.add(new BasicNameValuePair(MoonConstants.USER_HEAD_IMAGE, params[3]));
            pairs.add(new BasicNameValuePair(MoonConstants.USER_EMAIL, params[4]));

            return pairs;
        }

        /**
         * 写入用户信息
         */
        private void writeSharedData(UserJsonResult result) {
            SharedPreferences shareDate = getSharedPreferences(
                    MoonConstants.SHARED_PREFERENCES_KEY, Context.MODE_PRIVATE);
            SharedPreferencesUtils.writeUserData(shareDate, result.getObject());
        }
    }

    
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
            startActivity(new Intent(UserSettingActivity.this, MainActivity.class));
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }
}
